
import java.io.Serializable;
import java.util.GregorianCalendar;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Observable;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
/*
 * Classe controleur et application (système)
 * @author IUT,   A. Culet
 * @version 1.0 
 */

import com.sun.org.apache.xalan.internal.xsltc.compiler.Pattern;


public class Controleur implements Serializable{
	
	private static final long serialVersionUID = 1L;

	/**
	 * La classe Controleur est unique pour tous les cas d'utilisation
	 * Elle est également la classe "application" qui gère l'ensemble des objets de l'appli
	 */	
	// ************************************************************************************************************
		// Attributs
		// ************************************************************************************************************
	
		// Attributs d'Association
		// Ensemble des ouvrages de la bibliothèque
		private HashMap<String, Ouvrage> _ouvrages;
		private HashMap<String , Auteur> auteurs;
		private HashMap<String , Periodique> periodiques;
		private HashMap<Integer, Lecteur> lecteurs;
		private HashMap<String, Article> articles;
		
		public static float PENALITE = 1.00f;
		public static int MAXEMPRUNT = 5;
		public static int DUREEEMPRUNT = 7;
		
		// la liste des vues. La 1ere est toujours la vue Menu Principal. La dernière est la vue active.
		private LinkedList<Vue> _vues;
		
		
		// ************************************************************************************************************
		// Constructeur
		// ************************************************************************************************************

		public Controleur() {
			_ouvrages = new HashMap<String, Ouvrage>();
			periodiques = new HashMap<String, Periodique>();
			auteurs = new HashMap<String , Auteur>();
			lecteurs = new HashMap<Integer, Lecteur>();
			articles = new HashMap<String, Article>();
			this.setOuvrages(new HashMap<String, Ouvrage>());
			_vues = new LinkedList<Vue>();
		} // Fin Controleur

		// ************************************************************************************************************
		// Méthodes privées
		// ************************************************************************************************************

		// ------------------------------------------------------------------------------------------------------------
		// Affecteurs
		
		/**
		 * Ajoute un ouvrage à l'ensemble des ouvrages de la bibliothèque.
		 * @param ouvrage 	Ouvrage à ajouter
		 * @param isbn 	code ISBN de cet ouvrage
		 */
		private void setOuvrage(Ouvrage ouvrage, String isbn) {
			this.getOuvrages().put(isbn, ouvrage);
		} // Fin setOuvrage
		
		private void setPeriodique(Periodique periodique, String issn) {
			this.getPeriodiques().put(issn, periodique);
		}

		/**
		 * @param ouvrages hashtable d'ouvrages à affecter
		 */
		private void setOuvrages(HashMap<String, Ouvrage> ouvrages) {
			_ouvrages = ouvrages;
		}// Fin setOuvrages
		
		private void addArticle(String titreArticle, Article article){
			getArticles().put(titreArticle, article);
		}
		
		/**
		 * ajoute ou enlève la vue active courante de la liste des vues
		 * @param vue  la vue à affecter
		 */
		 private void setVue(Vue vue) {
				_vues.addLast(vue);
		 }
		 private void removeVue() {
				_vues.removeLast();
		 }
		
		/*
		// ------------------------------------------------------------------------------------------------------------
		// Accesseurs
		
		/**
		 * @return ensemble des ouvrages de la bibliothèque
		 */
		private HashMap<String, Ouvrage> getOuvrages() {
			return _ouvrages;
		}// Fin getOuvrages

		private HashMap<String, Periodique> getPeriodiques() {
			return periodiques;
		}
		
		/**
		 * Accès à un ouvrage par son numéro ISBN
		 * @param isbn 	le code ISBN de l'ouvrage cherché
		 * @return l'ouvrage qui a l'ISBN indiqué
		 */
		private Ouvrage getOuvrage(String isbn) {
			return this.getOuvrages().get(isbn);
		} // Fin getOuvrage

		private Periodique getPeriodique(String issn) {
			return this.getPeriodiques().get(issn);
		}
		
		private HashMap<String, Article> getArticles() {
			return articles;
		}
		
		private Lecteur getLecteur(int numLecteur)
		{
			Lecteur lect;
			if(numLecteur < lecteurs.size())
				lect = lecteurs.get(numLecteur);
			else
				lect = null;
			return lect;
		}

		private HashMap<String, Auteur> getAuteurs()
		{
			return auteurs;
		}
		
		private Auteur getAuteur(String autKey)
		{
			return auteurs.get(autKey);
		}
		
		public Article getArticle(String titreArticle) {	
			return this.getArticles().get(titreArticle);
		}	
		
		
		/**
		 * @return la vue active courante 
		 */
		private Vue getVue() {
			return (Vue)_vues.getLast() ;
		}
		/**
		 * @return la vue Menu Principal 
		 */
		private VueMenuBiblio getVueMenu() {
			
			return (VueMenuBiblio)_vues.getFirst() ;
		}
		
		/*
		// ************************************************************************************************************
		// Méthodes publiques de création et affichage des fenêtres de l'application et fermeture
		// ************************************************************************************************************
		/**
		 * Création et affichage de la fenêtre principale de l'application. 
		 * Elle propose le menu de l'appli
		 */

		public void menuBiblio() {
			
			try {this.setVue(new VueMenuBiblio(this));
				this.getVueMenu().setVisible(true); 	
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		/**
		 * Cas d'utilisation : consultation d'un ouvrage
		 * Création et affichage de la fenêtre de consultation d'un ouvrage
		 */
		
		public void consulterOuvrage() {
			try {
			this.setVue (new VueConsultOuvrage(this));
			// le Menu est caché
				this.getVueMenu().setVisible(false); 	
			// la vue courante est VueConsultOuvrage
				this.getVue().setEtat(Vue.initiale);
				this.getVue().setVisible(true);
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		
		/*
		 * Cas d'utilisation : consultation d'un periodique
		 * Création et affichage de la fenêtre de consultation d'un periodique
		 */
		
		public void consulterPeriodique() {
			try {this.setVue (new VueConsultPeriodique(this));
				// le Menu est caché
					this.getVueMenu().setVisible(false); 	
				// la vue courante est VueConsultOuvrage
					this.getVue().setEtat(Vue.initiale);
					this.getVue().setVisible(true);
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		
		/*
		 * Ouverture de la vue de consultation d'un lecteur
		 * 
		 */
		public void consulterLecteur()
		{
			try {this.setVue (new VueConsultLecteur(this));
			// le Menu est caché
				this.getVueMenu().setVisible(false); 	
			// la vue courante est VueConsultOuvrage
				this.getVue().setEtat(Vue.initiale);
				this.getVue().setVisible(true);
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		
		/*
		 * Ouverture de la vue			_ouvrages = new HashMap<String, Ouvrage>();
			periodiques = new HashMap<String, Periodique>();
			auteurs = new HashMap<String , Auteur>();
			lecteurs = new HashMap<Integer, Lecteur>(); de création d'un nouveau lecteur
		 * 
		 */
		public void saisirLecteur()
		{
			try {this.setVue (new VueSaisieLecteur(this));
			// le Menu est caché
				this.getVueMenu().setVisible(false); 	
			// la vue courante est VueConsultOuvrage
				this.getVue().setEtat(Vue.initiale);
				this.getVue().setVisible(true);
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		
		public void saisirEmprunt()
		{
			try {this.setVue (new VueSaisieEmprunt(this));
			// le Menu est caché
				this.getVueMenu().setVisible(false); 	
			// la vue courante est VueConsultOuvrage
				this.getVue().setEtat(Vue.initiale);
				this.getVue().setVisible(true);
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		
		
		/**
		 * Cas d'utilisation : saisie d'un exemplaire d'ouvrage
		 * Création et affichage de la fenêtre de saisie d'un exemplaire d'ouvrage
		 */
		public void saisirExemplaire() {
			try {this.setVue(new VueSaisieExemplaire(this));
			// le Menu est caché
				this.getVueMenu().setVisible(false); 
			// la vue courante est VueSaisieExemplaire
				this.getVue().setEtat(Vue.initiale);
				this.getVue().setVisible(true);
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		/**
		 * cas d'utilisation : saisie d'un ouvrage
		 * Création et affichage de la fenêtre de saisie d'un ouvrage
		 */
		public void saisirOuvrage() {
			try {this.setVue(new VueSaisieOuvrage(this));
			// le Menu est caché
				this.getVueMenu().setVisible(false); 
			// la vue courante est VueSaisieOuvrage
				this.getVue().setEtat(Vue.initiale);
				((VueSaisieOuvrage)this.getVue()).alimenteAutName(auteurs);
				this.getVue().setVisible(true);
			} catch (Exception e) {
			e.printStackTrace();
			}
		}
		
		public void saisirPeriodique() {
			try {this.setVue(new VueSaisiePeriodique(this));
			// le Menu est caché
				this.getVueMenu().setVisible(false); 
			// la vue courante est VueSaisieOuvrage
				this.getVue().setEtat(Vue.initiale);
				this.getVue().setVisible(true);
			} catch (Exception e) {
			e.printStackTrace();
			}
		}	
		
		//Saisir un article
		public void saisirArticle() {
			try {this.setVue(new VueSaisieArticle(this, getAuteurs()));			
			// la vue courante est VueSaisieArticle
				this.getVue().setEtat(Vue.initiale);
				this.getVue().setVisible(true);
			} catch (Exception e) {
			e.printStackTrace();
			}
		}		
		
		
		public void saisirParution() {
			try {this.setVue(new VueSaisieParution(this, articles));
			// le Menu est caché
				this.getVueMenu().setVisible(false); 
			// la vue courante est VueEnregistrerParution
				this.getVue().setEtat(Vue.initiale);
				this.getVue().setVisible(true);
			} catch (Exception e) {
			e.printStackTrace();
			}
		}
		
		public void retourEmprunt()
		{
			try {this.setVue(new VueRetourEmprunt(this));
			// le Menu est caché
				this.getVueMenu().setVisible(false); 
			// la vue courante est VueEnregistrerParution
				this.getVue().setEtat(Vue.initiale);
				this.getVue().setVisible(true);
			} catch (Exception e) {
			e.printStackTrace();
			}
		}
		
		public void parametrerQuotas()
		{
			try {this.setVue(new VueParamQuota(this));
			// le Menu est caché
				this.getVueMenu().setVisible(false); 
			// la vue courante est VueEnregistrerParution
				this.getVue().setEtat(Vue.initiale);
				this.getVue().setVisible(true);
			} catch (Exception e) {
			e.printStackTrace();
			}
		}
		
		
		
		/**
		 * fermeture de la fenêtre vue
		 * lors de la fermeture de la fenêtre principale de l'application sauvegarde des objets sérialisés 
		 */
		public void fermerVue (Vue vue) {
			//la vue est détruite et n'est plus la vue active courante	
			
			if (vue instanceof VueMenuBiblio ) {
			// Quitte l'aplication. Sauvegarde les objets du modèle
				vue.dispose();
				this.removeVue();
				this.sauve();
				System.exit(0);
				}
			else {
			// le Menu est rendu de nouveau visible
			
				vue.dispose();
				this.removeVue();
				if(!(vue instanceof VueSaisieArticle))
					this.getVueMenu().setVisible(true); 
			}
		}
		
		/*
		// ************************************************************************************************************
		// Opérations liées à la sérialisation des objets de l'application
		// ************************************************************************************************************
		/**
		 *  restauration des objets de l'application
		 */
		public Controleur restaure() {
			try {
				FileInputStream fichier = new FileInputStream("Fsauv.ser");
				ObjectInputStream in = new ObjectInputStream(fichier);
				return((Controleur) in.readObject());
			} catch (Exception e) {
				Message dialog = new Message("Pbs de Restauration ou fichier non encore créé");
				return this;
			} 
		}
		/**
		 *  sauvegarde des objets de l'application
		 */
		private void sauve() {
			try {
				FileOutputStream f = new FileOutputStream("Fsauv.ser");
				ObjectOutputStream out = new ObjectOutputStream(f);
				out.writeObject(this);
			} catch (Exception e) {
				Message dialog = new Message("Pb de Sauvegarde dans le fichier");
			}
		}
		// ************************************************************************************************************
		// Opérations liées à l'application en réponse à une action de l'utilisateur dans une vue
		// ************************************************************************************************************

		/**
		 * Accès à un ouvrage par son numéro ISBN
		 * Invoqué dans VueConsultOuvrage et VueSaisieExemplaire
		 * @param isbn 	le code ISBN de l'ouvrage cherché
		 * @return l'ouvrage qui a l'ISBN indiqué ou null
		 * affiche un message d'erreur si l'ouvrage n'est pas trouvé
		 */
		public Ouvrage rechOuvrage(String isbn) {
			Message dialog;
			Ouvrage ouv = null;
			if(isbn.isEmpty())
			{
				dialog = new Message("isbn vide.");
				if (this.getVue() instanceof VueSaisieEmprunt)
				{
					System.out.println("Introuvable");
					this.getVue().setEtat(Vue.initiale);
				}
			}
			else
			{
				ouv = this.getOuvrage(isbn);
				if (ouv == null) {
					dialog = new Message("Ouvrage inconnu");
					if (this.getVue() instanceof VueSaisieEmprunt)
					{
						System.out.println("Introuvable");
						this.getVue().setEtat(Vue.initiale);
					}
				}
				else {
					// la vue courante est VueSaisieExemplaire
					if (this.getVue() instanceof VueSaisieExemplaire){
					// la vue est inscrite comme observatrice de l'ouvrage	
						ouv.addObserver(this.getVue());
					// le contrôleur modifie l'état de la vue
						this.getVue().setEtat(Vue.inter1);	
					// le controleur demande à la vue d'afficher les infos de l'ouvrage
						((VueSaisieExemplaire)this.getVue()).alimente(ouv);
						}
					// la vue courante est VueConsultOuvrage
					else if (this.getVue() instanceof VueConsultOuvrage)
					{
						// le contrôleur modifie l'état de la vue
						this.getVue().setEtat(Vue.finale);
						((VueConsultOuvrage)this.getVue()).alimente(ouv);
					}
					else if(this.getVue() instanceof VueSaisieEmprunt)
					{
						this.getVue().setEtat(Vue.inter1);
						((VueSaisieEmprunt)this.getVue()).alimente(ouv);
					}
				}
			}
			return ouv;
		} // Fin rechOuvrage
		
		
		public Periodique rechPeriodique(String issn) {
			Message dialog;
			Periodique per = null;
			String mes = "";
			boolean popup = true;
			if (issn.isEmpty())
			{
				mes = "Issn vide. ";
			}
			else
			{
				per = this.getPeriodique(issn);
				if (per == null) {
					mes = "Periodique inconnu";
				}
				else if(getVue() instanceof VueConsultPeriodique)
				{
					popup= false;
					per.addObserver(getVue());
					((VueConsultPeriodique)this.getVue()).alimente(per);
				}
				else if(getVue() instanceof VueSaisieParution)	
				{
					popup= false;
					((VueSaisieParution)this.getVue()).alimente(per, getArticles());
					getVue().setEtat(Vue.finale);
				}

			}
			if(popup)
			{
				dialog = new Message(mes);
				getVue().setEtat(Vue.initiale);
			}
			return per;
		}	
		
		
		
		
		
		/**
		 * Accès à un Lecteur par son numéro Lecteur
		 * Invoqué dans VueConsultLecteur
		 * @param numLecteur Le numéro du Lecteur cherché
		 * @return Le lecteur associé à ce numéro ou null
		 * affiche un message d'erreur si le Lecteur n'est pas trouvé
		 */
		public Lecteur rechLecteur(String numLecteur)
		{
			boolean erreur = false;
			Lecteur lect = null;
			if (numLecteur.isEmpty())
			{
				Message dialog = new Message("Veuillez indiquer un numéro de lecteur");
				erreur = true;
			}
			else
			{
				try{
					lect = this.getLecteur(Integer.parseInt(numLecteur));
					if(lect != null)
					{
						if (this.getVue() instanceof VueConsultLecteur)
						{
							((VueConsultLecteur)getVue()).alimente(lect);
							this.getVue().setEtat(Vue.finale);
						}
						else if( this.getVue() instanceof VueRetourEmprunt)
						{
							((VueRetourEmprunt)getVue()).alimente(lect);
							this.getVue().setEtat(Vue.inter1);
						}
					}
					else
					{
						Message Dialog = new Message("Lecteur inexistant.");
						erreur = true;
					}
				}
				catch (NumberFormatException nfe) {     
				     Message Dialog = new Message("Format du numéro lecteur incorrecte.");
				     erreur = true;
				 }
			}
			if (this.getVue() instanceof VueConsultLecteur && erreur)
			{
				this.getVue().setEtat(Vue.initiale);
			}
			if (this.getVue() instanceof VueRetourEmprunt && erreur)
			{
				this.getVue().setEtat(Vue.initiale);
			}
			return lect;
		} // Fin rechOuvrage
		
		public void consulterRechAuteur()
		{
			try {this.setVue(new VueRechAuteur(this));
			// le Menu est caché
				this.getVueMenu().setVisible(false); 
			// la vue courante est VueSaisieOuvrage
				this.getVue().setEtat(Vue.initiale);
				((VueRechAuteur)this.getVue()).alimenteAutName(auteurs);
				this.getVue().setVisible(true);
			} catch (Exception e) {
			e.printStackTrace();
			}
		}
		
		// ---------------------------------------------------------------------
				public void rechAuteur(String auteur){
					Auteur aut = getAuteur(auteur);
					if(aut == null){
						Message dialog = new Message("Auteur inconnu");
					}
					else{
						((VueRechAuteur)this.getVue()).alimenteAutOuvrage(aut.getOuvrage());
					}
				}

				
				
				
				// ---------------------------------------------------------------------
		
		
		/**
		 * Création d'un exemplaire d'ouvrage 
		 * Invoqué dans VueSaisieExemplaire
		 * @param ouv l'ouvrage  dateRecep la date de réception de l'exemplaire	
		 * affiche un message de confirmation après l'enregistrement ou un message d'erreur 
		 */
		public void nouvExemplaire(Ouvrage ouv, String dateReception, String statut) {
			// vérification de la présence de la date et de son format
			if (dateReception.length() == 0 ){
					Message dialog = new Message("La date de réception est obligatoire");
					}
			else {
				GregorianCalendar date = ESDate.lireDate (dateReception);
				if (date == null) {
					Message dialog = new Message("Le format de la date est incorrect");
					}
				else {
					int statutEx;
					if (statut == "empruntable") {
						statutEx = Exemplaire.EMPRUNTABLE ; }
					else {
						statutEx = Exemplaire.EN_CONSULTATION ; }
			// demande d'ajout de l'exemplaire
					Exemplaire exemplaire = ouv.ajouterExemplaire(date, statutEx);
			// l'opération s'est bien passée
					if (exemplaire != null) {
			// le contrôleur modifie l'état de la vue
						this.getVue().setEtat(Vue.finale);
			// affichage d'un message de confirmation
						Message dialog = new Message("Exemplaire enregistré");
					}
					else {
						Message dialog = new Message("Date de Reception incorrecte / à la date d'Edition.");
					}
				}
			}
		} // Fin nouvExemplaire
		
		/**
		 * Création d'un  d'ouvrage 
		 * Invoqué dans VueSaisieOuvrage
		 * @param  dateEdition la date d'édition de l'ouvrage
		 * affiche un message de confirmation après l'enregistrement ou un message d'erreur 
		 */
		public void nouvOuvrage(String isbn, String titre, String auteur, String editeur, String dateEdition) {
			// vérification de la présence des infos obligatoires et du format de la date
			if ((isbn.length() == 0) || (titre.length() == 0) || (auteur.length() == 0) 
					|| (editeur.length() == 0 )|| (dateEdition.length() == 0 )){
					Message dialog = new Message("Tous les champs sont obligatoires");
					}
			else {
				GregorianCalendar date = ESDate.lireDate (dateEdition);
				if (date == null) 
				{
					Message dialog = new Message("Le format de la date est incorrect");
				}
				else if (this.getOuvrage(isbn )== null) 
					{
					// Instanciation de l'ouvrage
						String prenom = auteur.split(" ")[1];
						String nom = auteur.split(" ")[0];
						Auteur aut = new Auteur(nom, prenom);
						ajouterAuteur(aut);
						Ouvrage ouvrage = new Ouvrage(isbn, titre, aut, editeur, date);
						aut.addOuvrage(ouvrage);
					// Ajout de l'ouvrage dans l'ensemble des ouvrages de la bibliothèque
						this.setOuvrage(ouvrage, isbn);
						
						Message dialog = new Message("Ouvrage enregistré");
						this.fermerVue (this.getVue());
					} 
					else 
					{
						Message dialog = new Message("Ouvrage déjà présent");
					}
				}
			}// Fin nouvOuvrage
		
		public void nouvPeriodique(String issn, String nom) 
		{
			// vérification de la présence des infos obligatoires et du format de la date
			Message dialog;
			String mes = "";
			boolean valide = true;;
			if (issn.isEmpty())
			{
				if(valide)
					mes = "Issn vide. ";
				else
					mes += "Issn vide. ";
				valide = false;
			}
			if(nom.isEmpty())
			{
				if(valide)
					mes = "Nom vide. ";
				else
					mes += "Nom vide. ";
				valide = false;
			}
			if(valide)
			{
				if (this.getPeriodique(issn )== null) 
				{
				// Instanciation du periodique

					Periodique periodique = new Periodique(issn, nom);
				// Ajout du periodique dans l'ensemble des periodiques de la bibliothèque
					this.setPeriodique(periodique, issn);
					
					mes = "Periodique enregistré";
					this.fermerVue (this.getVue());
				} 
				else 
				{
					mes = "Ce numéro issn est déjà utilisé.";
				}
			}
			dialog = new Message(mes);
		}
		
		
		public void nouvLecteur(String prenom, String nom, String adresse, String tel)
		{
			boolean valide = true;
			Message dialog;
			String mes = "";
			if(prenom.isEmpty())
			{
				if(valide)
					mes = "Prenom vide.\n ";
				else
					mes += "Prenom vide.\n ";
				valide = false;
			}
			if(nom.isEmpty())
			{
				if(valide)
					mes = "Nom vide.\n ";
				else
					mes += "Nom vide.\n ";
				valide = false;
			}
			if(adresse.isEmpty())
			{
				if(valide)
					mes = "Adresse vide.\n ";
				else
					mes += "Adresse vide.\n ";
				valide = false;
			}
			if(tel.isEmpty())
			{
				if(valide)
					mes = "Numéro de téléphone vide.\n ";
				else
					mes += "Numéro de téléphone vide.\n ";
				valide = false;
			}
			else
			{
				if(!tel.matches("[0-9]{10}"))
				{
					if(valide)
						mes = "Numéro de téléphone invalide.\n ";
					else
						mes += "Numéro de téléphone invalide.\n ";
					valide = false;
				}
			}
			if(valide)
			{
				Lecteur newLect = new Lecteur(prenom,nom,adresse,tel);
				lecteurs.put(newLect.getNum(), newLect);
				dialog = new Message("Lecteur enregistré avec l'identifiant : " + newLect.getNum());
				fermerVue(getVue());
			}
			else
				dialog = new Message(mes);
		}
			
			public void nouvEmprunt(String numLect, Exemplaire ex, String dateDeb, String dateFin)
			{
				Message dialog;
				GregorianCalendar dateD = ESDate.readDate(dateDeb);
				Lecteur lect = null;
				try{
					lect = getLecteur(Integer.parseInt(numLect));
					if(lect != null)
					{
						if(lect.peutEmprunter())
						{
							if (dateD == null) 
								dialog = new Message("Le format de la date début est incorrect");
							GregorianCalendar dateF = ESDate.readDate(dateFin);
							if (dateF == null) 
								dialog = new Message("Le format de la date de retour est incorrect");
							Emprunt newEmprunt = new Emprunt(lect, ex, dateD, dateF);
							ex.setStatut(Exemplaire.EMPRUNTE);
							lect.ajouterEmprunt(newEmprunt);
							dialog = new Message("L'exemplaire numéro " + ex.getNumero() + " a été emprunté par le lecteur " + lect.getNum());
							this.fermerVue(getVue());
						}
						else
						{
							dialog = new Message("Ce lecteur dispose d'un emprunt en retard, ou a dépassé le quota d'emprunts.");
						}
					}
					else
					{
						dialog = new Message("Numéro lecteur inexistant.");
					}
				}
				catch (NumberFormatException nfe) {     
				     Message Dialog = new Message("Format du numéro lecteur incorrecte.");
				 }
			
			}
			
			//Nouvel article
			public void nouvArticle(String titreArticle, String auteur) {
				if ((titreArticle.length() == 0) || (auteur.length() == 0)){
						Message dialog = new Message("Tous les champs sont obligatoires");
						}
				else {
					
					if (this.getArticle(titreArticle)== null) 
						{
						// Instanciation de l'article
							String prenom = auteur.split(" ")[1];
							String nom = auteur.split(" ")[0];
							Auteur aut = new Auteur(nom, prenom);
							ajouterAuteur(aut);
							Article article = new Article(titreArticle, aut);
						// Ajout de l'article dans l'ensemble des articles de la bibliothèque
							this.addArticle(titreArticle, article);
							Message dialog = new Message("Article enregistré");
							this.fermerVue(this.getVue());
							((VueSaisieParution)getVue()).update(article);
						} 
						else 
						{
							Message dialog = new Message("Article déjà présent");
						}
					}
				}
			
			public void nouvParution(String issn, String IdParution, Object[] art) {
				boolean valide = true;
				Message dialog;
				String mes = "";
				if(issn.isEmpty())
				{
					if(valide)
						mes = "Issn vide. ";
					else
						mes += "Issn vide. ";
					valide = false;
				}
				if(IdParution.isEmpty())
				{
					if(valide)
						mes = "Id parution vide. ";
					else
						mes += "Id parution vide. ";
					valide = false;
				}
				if(art.length == 0 || art == null)
				{
					if(valide)
						mes = "La parution ne contient aucun article. ";
					else
						mes += "La parution ne contient aucun article. ";
					valide = false;
				}
				if(valide)
				{
					Periodique per = this.getPeriodique(issn);
					Parution parution = new Parution(IdParution, per);
					for(int i = 0; i< art.length; i++)
						parution.ajouterArticle(articles.get(art[i]));
					per.ajouterParution(parution);
					mes = ("Parution ajoutée. ");
					this.fermerVue(this.getVue());
				}
				dialog = new Message(mes);
			}
			
			
			public void supprEmprunt(Lecteur lect, int index)
			{
				Exemplaire ex = lect.getEmprunts().get(index).getExemplaire();
				ex.setStatut(Exemplaire.EMPRUNTABLE);
				lect.supprimerEmprunt(index);
				Message dialog = new Message("Exemplaire retourné");
				this.fermerVue(this.getVue());
			}
			
			public void setQuotas(String Sprix, String Sduree, String Snombre)
			{
				boolean check = true, modif = false;
				String mes = "Aucun quota n'a été modifié";
				Message dialog;
				float prix = 0;
				int duree = 0, nombre =0;
				try
				{
					prix = Float.parseFloat(Sprix);
				}
				catch(NumberFormatException nfe)
				{
					if(check)
						mes = "Le prix indiqué est invalide.";
					else
						mes += "Le prix indiqué est invalide.";
					check = false;
				}
				try
				{
					duree = Integer.parseInt(Sduree);
				}
				catch(NumberFormatException nfe)
				{
					if(check)
						mes = "Le temps d'emprunt indiqué est invalide.";
					else
						mes += "Le temps d'emprunt indiqué est invalide.";
					check = false;
				}
				try
				{
					nombre = Integer.parseInt(Snombre);
				}
				catch(NumberFormatException nfe)
				{
					if(check)
						mes = "Le nombre d'emprunt maximum indiqué est invalide.";
					else
						mes += "Le nombre d'emprunt maximum indiqué est invalide.";
					check = false;
				}
				if(check)
				{
					if(PENALITE != prix)
					{
						if(!modif)
							mes = "Quota pénalité modifié.\n ";
						else
							mes += "Quota pénalité modifié.\n ";
						PENALITE = prix;
						modif = true;
					
					}
					if(MAXEMPRUNT != nombre)
					{
						if(!modif)
							mes = "Quota nombre emprunts modifié.\n ";
						else
							mes += "Quota nombre emprunts modifié.\n ";
						MAXEMPRUNT = nombre;
						modif = true;
						
					}
					if(DUREEEMPRUNT != duree)
					{
						if(!modif)
							mes = "Quota durée emprunt modifié.\n ";
						else
							mes += "Quota durée emprunt modifié.\n ";
						DUREEEMPRUNT = duree;
						modif = true;
						
					}
					if(modif)
						((VueParamQuota)getVue()).setEtat(Vue.finale);
				}
				dialog = new Message(mes);
			}
			
			public void ajouterAuteur(Auteur newAuteur)
			{
				String key = newAuteur.getNom() + " " + newAuteur.getPrenom();
				if(getAuteur(key) == null)
					auteurs.put(key, newAuteur);
			}
		} 



		

